home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / c / amivogl-1.03.lzh / vogl / drivers / decX11.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-15  |  11.5 KB  |  581 lines
  1. /*
  2.  * VOGLE driver for X11 under the DEC window manager.
  3.  *
  4.  *    ok so we admit that we don't know heaps about X11, but come
  5.  * on guys, this shouldn't be neccessary (wild comment from DEC about
  6.  * why our standard X11 driver won't work is welcome.)
  7.  */
  8. #include <stdio.h>
  9. #include <X11/Xlib.h>
  10. #include <X11/Xutil.h>
  11.  
  12. #include "vogl.h"
  13.  
  14. #define LARGEX11R2    "courier12f.snf"
  15. #define SMALLX11R2    "courier10f.snf"
  16.  
  17. #define LARGEX11R3    "-adobe-courier-medium-r-normal--24-240-75-75-m-150-iso8859-1"
  18. #define SMALLX11R3    "-adobe-courier-medium-r-normal--10-100-75-75-m-60-iso8859-1"
  19.  
  20. #define MIN(x,y)    ((x) < (y) ? (x) : (y))
  21. #define    CMAPSIZE    256
  22. #define    EV_MASK        KeyPressMask|ButtonReleaseMask|ExposureMask|ButtonPressMask
  23.  
  24. static    Window        winder;
  25. static    Display        *display;
  26. static    int        screen;
  27. static    unsigned long    carray[CMAPSIZE];
  28. static    Colormap    colormap;
  29.  
  30. static    Drawable    theDrawable;
  31. static    GC        theGC;
  32. static    Pixmap        bbuf;        /* Back buffer pixmap */
  33. static    int        back_used;    /* Have we backbuffered ? */
  34.  
  35. static    XFontStruct    *font_id;
  36. XEvent            event;
  37.  
  38. static    int        size;
  39. static    unsigned long    colour;
  40. static    unsigned int    h, w;
  41.  
  42. /*
  43.  * DECX11_init
  44.  *
  45.  *    initialises X11 display.
  46.  */
  47. int DECX11_init(void)
  48. {
  49.     int        i;
  50.     int        x, y, prefx, prefy, prefxs, prefys;
  51.     unsigned int    bw, depth, mask;
  52.     Window        rootw, childw, topwinder, *kiddies;
  53.     char        *av[2], name[50];
  54.  
  55.     XSetWindowAttributes    theWindowAttributes;
  56.         XSizeHints              theSizeHints;
  57.         unsigned long           theWindowMask;
  58.     XWMHints                theWMHints;
  59.  
  60.  
  61.     av[0] = "vogl.X11";
  62.     av[1] = (char *)NULL;
  63.  
  64.     if ((display = XOpenDisplay((char *)NULL)) == (Display *)NULL) {
  65.         fprintf(stderr,"vogl: DECX11_init: can't connect to X server\n");
  66.         exit(1);
  67.     }
  68.  
  69.     winder = DefaultRootWindow(display);
  70.     screen = DefaultScreen(display);
  71.     vdevice.depth = DefaultDepth(display, screen);
  72.     colormap = DefaultColormap(display, screen);
  73.  
  74.     /*
  75.      * Set our standard colors...
  76.      */
  77.     if (vdevice.depth == 1) {
  78.         /*
  79.          * Black and white - anything that's not black is white.
  80.          */
  81.         carray[0] = BlackPixel(display, screen);
  82.         for (i = 1; i < CMAPSIZE; i++)
  83.             carray[i] = WhitePixel(display, screen);
  84.     } else {
  85.         /*
  86.          * Color, try to get our colors close to what's in the
  87.          * default colormap.
  88.          */
  89.         DECX11_mapcolor(0, 0, 0, 0);
  90.         DECX11_mapcolor(1, 255, 0, 0);
  91.         DECX11_mapcolor(2, 0, 255, 0);
  92.         DECX11_mapcolor(3, 255, 255, 0);
  93.         DECX11_mapcolor(4, 0, 0, 255);
  94.         DECX11_mapcolor(5, 255, 0, 255);
  95.         DECX11_mapcolor(6, 0, 255, 255);
  96.         DECX11_mapcolor(7, 255, 255, 255);
  97.     }
  98.  
  99.     getprefposandsize(&prefx, &prefy, &prefxs, &prefys);
  100.  
  101.     XQueryPointer(display, winder, &rootw, &childw, &x, &y, &x, &y, &mask);
  102.  
  103.     if (childw == None)
  104.         childw = rootw;
  105.  
  106.     /*
  107.      * there is something very weird about dec's window manager
  108.      * as expressed on a dec station, to get the details for the window
  109.      * we are actually in we have to get the root window of the childw
  110.      * which gives us the root window of the real window stack, and then
  111.      * we use XQueryPointer to find the real child window.
  112.      */
  113.  
  114.     XQueryTree(display, childw, &rootw, &rootw, &kiddies, &i);
  115.  
  116.     topwinder = winder;
  117.     winder = kiddies[0];
  118.     XQueryPointer(display, winder, &rootw, &childw, &x, &y, &x, &y, &mask);
  119.  
  120.     XGetGeometry(display, childw, &rootw, &x, &y, &w, &h, &bw, &depth);
  121.  
  122.     if (prefx > -1) {
  123.             x = prefx;
  124.             y = prefy;
  125.     }
  126.  
  127.     if (prefxs > -1) {
  128.             w = prefxs;
  129.             h = prefys;
  130.     }
  131.  
  132.     x += bw;
  133.     y += bw;
  134.  
  135.     w -= 2 * bw;
  136.     h -= 2 * bw;
  137.  
  138.     theWindowAttributes.override_redirect = False;
  139.  
  140.         /*theWindowMask = CWBackPixel|CWBorderPixel|CWOverrideRedirect;*/
  141.  
  142.         theWindowMask = CWOverrideRedirect;
  143.  
  144.         winder = XCreateWindow(display,
  145.                                 topwinder,
  146.                                 x, y,
  147.                                 w, h,
  148.                                 bw,
  149.                                 (int)depth,
  150.                                 InputOutput,
  151.                                 CopyFromParent,
  152.                                 theWindowMask,
  153.                                 &theWindowAttributes
  154.                         );
  155.  
  156.         theWMHints.initial_state = NormalState;
  157.         theWMHints.flags = StateHint;
  158.         XSetWMHints(display, winder, &theWMHints);
  159.  
  160.         theSizeHints.flags = PPosition|PSize;
  161.         theSizeHints.x = x;
  162.         theSizeHints.y = y;
  163.         theSizeHints.width = w;
  164.         theSizeHints.height = h;
  165.  
  166.         XSetNormalHints(display, winder, &theSizeHints);
  167.  
  168.     sprintf(name, "vogl %d", getpid());
  169.  
  170.     XSetStandardProperties(display,
  171.         winder,
  172.         name,
  173.         name,
  174.         None,
  175.         av,
  176.         1,
  177.         &theSizeHints
  178.     );
  179.  
  180.     XSelectInput(display, winder, EV_MASK);
  181.  
  182.     theDrawable = (Drawable)winder;
  183.  
  184.     /*
  185.      *  Let VOGLE know about the window size.
  186.      */
  187.     vdevice.sizeX = vdevice.sizeY = MIN(h, w) - 1;
  188.     vdevice.sizeSx = w - 1;
  189.     vdevice.sizeSy = h - 1;
  190.  
  191.     /*
  192.      * Create Graphics Context and Drawable
  193.      */
  194.     theGC = XDefaultGC(display, screen);
  195.     theDrawable = (Drawable)winder;
  196.     DECX11_color(0);
  197.  
  198.     XMapRaised(display, winder);
  199.     XFlush(display);
  200.  
  201.     /*
  202.      * Wait for Exposure event.
  203.      */
  204.     do {
  205.         XNextEvent(display, &event);
  206.     } while (event.type != Expose);
  207.  
  208.     if (prefx == -1 && prefxs == -1)
  209.         XSetInputFocus(display, winder, RevertToParent, CurrentTime);
  210.  
  211.     back_used = 0;
  212.  
  213.     return(1);
  214. }
  215.  
  216. /*
  217.  * DECX11_exit
  218.  *
  219.  *    cleans up before returning the window to normal.
  220.  */
  221. int DECX11_exit(void)
  222. {
  223.     XFreeGC(display, theGC);
  224.  
  225.     if (back_used) 
  226.         XFreePixmap(display, bbuf);
  227.  
  228.     XUnmapWindow(display, winder);
  229.  
  230.     XDestroyWindow(display, winder);
  231.  
  232.     return(1);
  233. }
  234.  
  235. /*
  236.  * DECX11_draw
  237.  *
  238.  *    draws a line from the current graphics position to (x, y).
  239.  *
  240.  * Note: (0, 0) is defined as the top left of the window in X (easy
  241.  * to forget).
  242.  */
  243. int DECX11_draw(
  244.   int x,
  245.   int y)
  246. {
  247.     XDrawLine(display,
  248.         theDrawable,
  249.         theGC,
  250.         vdevice.cpVx, vdevice.sizeSy - vdevice.cpVy,
  251.         x, vdevice.sizeSy - y
  252.     );
  253.  
  254.     XFlush(display);
  255. }
  256.  
  257. /*
  258.  * DECX11_getkey
  259.  *
  260.  *    grab a character from the keyboard - blocks until one is there.
  261.  */
  262. int DECX11_getkey(void)
  263. {
  264.     char    c;
  265.  
  266.     do {
  267.         XNextEvent(display, &event);
  268.         if (event.type == KeyPress) {
  269.             if (XLookupString(&event, &c, 1, NULL, NULL) > 0)
  270.                 return((int)c);
  271.             else
  272.                 return(0);
  273.         }
  274.     } while (event.type != KeyPress);
  275. }
  276.  
  277. /*
  278.  * DECX11_checkkey
  279.  *
  280.  *    Check if there has been a keyboard key pressed.
  281.  *    and return it if there is.
  282.  */
  283. int DECX11_checkkey(void)
  284. {
  285.     char    c;
  286.     int    i;
  287.  
  288.     if (!XCheckWindowEvent(display, winder, KeyPressMask, &event))
  289.         return(0);
  290.  
  291.     if (event.type == KeyPress)
  292.         if (XLookupString(&event, &c, 1, NULL, NULL) > 0)
  293.             return((int)c);
  294.  
  295.     return(0);
  296. }
  297.  
  298. /*
  299.  * DECX11_locator
  300.  *
  301.  *    return the window location of the cursor, plus which mouse button,
  302.  * if any, is been pressed.
  303.  */
  304. int DECX11_locator(
  305.   int *wx,
  306.   int *wy)
  307. {
  308.     Window    rootw, childw;
  309.     int    x, y, mask;
  310.  
  311.     XQueryPointer(display, winder, &rootw, &childw, &x, &y, wx, wy, &mask);
  312.  
  313.     *wy = (int)vdevice.sizeSy - *wy;
  314.  
  315.     return(mask >> 8);
  316. }
  317.  
  318. /*
  319.  * DECX11_clear
  320.  *
  321.  * Clear the screen (or current buffer )to current colour
  322.  */
  323. int DECX11_clear(void)
  324. {
  325.     XSetBackground(display, theGC, colour);
  326.     XFillRectangle(display,
  327.         theDrawable,
  328.         theGC,
  329.         vdevice.minVx,
  330.         vdevice.minVy, 
  331.         (unsigned int)vdevice.maxVx,
  332.         (unsigned int)vdevice.maxVy
  333.     );
  334. }
  335.  
  336. /*
  337.  * DECX11_color
  338.  *
  339.  *    set the current drawing color index.
  340.  */
  341. int DECX11_color(int ind)
  342. {
  343.     colour = carray[ind];
  344.     XSetForeground(display, theGC, colour);
  345. }
  346.  
  347. /*
  348.  * DECX11_mapcolor
  349.  *
  350.  *    change index i in the color map to the appropriate r, g, b, value.
  351.  */
  352. int DECX11_mapcolor(
  353.   int i,
  354.   int r,
  355.   int g,
  356.   int b)
  357. {
  358.     int    stat;
  359.     XColor    tmp;
  360.  
  361.     if (i >= CMAPSIZE)
  362.         return(-1);
  363.  
  364.  
  365.     /*
  366.      * For Black and White.
  367.      * If the index is 0 and r,g,b != 0 then we are remapping black.
  368.      * If the index != 0 and r,g,b == 0 then we make it black.
  369.      */
  370.     if (vdevice.depth == 1) {
  371.         if (i == 0 && (r != 0 || g != 0 || b != 0)) 
  372.             carray[i] = WhitePixel(display, screen);
  373.         else if (i != 0 && r == 0 && g == 0 && b == 0)
  374.             carray[i] = BlackPixel(display, screen);
  375.     } else {
  376.         tmp.red = (unsigned short)(r / 255.0 * 65535);
  377.         tmp.green = (unsigned short)(g / 255.0 * 65535);
  378.         tmp.blue = (unsigned short)(b / 255.0 * 65535);
  379.         tmp.flags = 0;
  380.         tmp.pixel = (unsigned long)i;
  381.  
  382.         if ((stat = XAllocColor(display, colormap, &tmp)) == 0) {
  383.             fprintf(stderr, "XAllocColor failed (status = %d)\n", stat);
  384.             exit(1);
  385.         }
  386.         carray[i] = tmp.pixel;
  387.     }
  388.  
  389.     XFlush(display);
  390.     return(0);
  391. }
  392.     
  393. /*
  394.  * DECX11_font
  395.  *
  396.  *   Set up a hardware font. Return 1 on success 0 otherwise.
  397.  *
  398.  */
  399. int DECX11_font(char *fontfile)
  400. {
  401.     XGCValues    xgcvals;
  402.  
  403.     if (font_id != (XFontStruct *)NULL)
  404.         XFreeFont(display, font_id);
  405.  
  406.     if (strcmp(fontfile, "small") == 0) {
  407.         if ((font_id = XLoadQueryFont(display, SMALLX11R2)) == (XFontStruct *)NULL) {        /* X11 R2 */
  408.             if ((font_id = XLoadQueryFont(display, SMALLX11R3)) == (XFontStruct *)NULL)         /* X11 R3 */
  409.                 return(0);
  410.             else
  411.                 fontfile = SMALLX11R3;
  412.         } else
  413.             fontfile = SMALLX11R2;
  414.     } else if (strcmp(fontfile, "large") == 0) {
  415.         if ((font_id = XLoadQueryFont(display, LARGEX11R2)) == (XFontStruct *)NULL) {        /* X11 R2 */
  416.             if ((font_id = XLoadQueryFont(display, LARGEX11R3)) == (XFontStruct *)NULL)         /* X11 R3 */
  417.                 return(0);
  418.             else
  419.                 fontfile = LARGEX11R3;
  420.         } else
  421.             fontfile = LARGEX11R2;
  422.     } else if ((font_id = XLoadQueryFont(display, fontfile)) == (XFontStruct *)NULL)
  423.         return(0);
  424.  
  425.     vdevice.hheight = font_id->max_bounds.ascent + font_id->max_bounds.descent;
  426.     vdevice.hwidth = font_id->max_bounds.width;
  427.  
  428.     xgcvals.font = XLoadFont(display, fontfile);
  429.     XChangeGC(display, theGC, GCFont, &xgcvals);
  430.  
  431.     return(1);
  432. }
  433.  
  434. /* 
  435.  * DECX11_char
  436.  *
  437.  *     outputs one char - is more complicated for other devices
  438.  */
  439. int DECX11_char(char c)
  440. {
  441.     char    *s = " ";
  442.  
  443.     s[0] = c;
  444.     XDrawString(display, theDrawable, theGC, vdevice.cpVx, (int)(vdevice.sizeSy - vdevice.cpVy), s, 1);
  445.     XFlush(display);
  446. }
  447.  
  448. /*
  449.  * DECX11_string
  450.  *
  451.  *    Display a string at the current drawing position.
  452.  */
  453. int DECX11_string(char s[])
  454. {
  455.     XDrawString(display, theDrawable, theGC, vdevice.cpVx, (int)(vdevice.sizeSy - vdevice.cpVy), s, strlen(s));
  456.     XSync(display, 0);
  457. }
  458.  
  459. /*
  460.  * DECX11_fill
  461.  *
  462.  *    fill a polygon
  463.  */
  464. int DECX11_fill(
  465.   int n,
  466.   int x[],
  467.   int y[])
  468. {
  469.     XPoint    plist[128];
  470.     int    i;
  471.  
  472.     if (n > 128)
  473.         verror("vogl: more than 128 points in a polygon");
  474.  
  475.     for (i = 0; i < n; i++) {
  476.         plist[i].x = x[i];
  477.         plist[i].y = vdevice.sizeSy - y[i];
  478.     }
  479.  
  480.     XFillPolygon(display, theDrawable, theGC, plist, n, Nonconvex, CoordModeOrigin);
  481.  
  482.     vdevice.cpVx = x[n-1];
  483.     vdevice.cpVy = y[n-1];
  484.  
  485.     XFlush(display);
  486. }
  487.  
  488. #define    GC_COPY_MASK    ~0
  489.  
  490. /*
  491.  * DECX11_backbuf
  492.  *
  493.  *    Set up double buffering by allocating the back buffer and
  494.  *    setting drawing into it.
  495.  */
  496. int DECX11_backbuf(void)
  497. {
  498.     if (!back_used)
  499.         bbuf = XCreatePixmap(display,
  500.             (Drawable)winder,
  501.             (unsigned int)vdevice.sizeSx + 1,
  502.             (unsigned int)vdevice.sizeSy + 1,
  503.             (unsigned int)vdevice.depth
  504.         );
  505.  
  506.     theDrawable = (Drawable)bbuf;
  507.  
  508.     back_used = 1;
  509.  
  510.     return(1);
  511. }
  512.  
  513. /*
  514.  * DECX11_swapbuf
  515.  *
  516.  *    Swap the back and from buffers. (Really, just copy the
  517.  *    back buffer to the screen).
  518.  */
  519. int DECX11_swapbuf(void)
  520. {
  521.     XCopyArea(display,
  522.         theDrawable,
  523.         winder,
  524.         theGC,
  525.         0, 0,
  526.         (unsigned int)vdevice.sizeSx + 1,
  527.         (unsigned int)vdevice.sizeSy + 1,
  528.         0, 0
  529.     );
  530.  
  531.     XSync(display, 0);    /* Not XFlush */
  532. }
  533.  
  534. /*
  535.  * DECX11_frontbuf
  536.  *
  537.  *    Make sure we draw to the screen.
  538.  */
  539. int DECX11_frontbuf(void)
  540. {
  541.     theDrawable = (Drawable)winder;
  542. }
  543.  
  544. /*
  545.  * the device entry
  546.  */
  547. static DevEntry DECX11dev = {
  548.     "decX11",
  549.     "large",
  550.     "small",
  551.     DECX11_backbuf,
  552.     DECX11_char,
  553.     DECX11_checkkey,
  554.     DECX11_clear,
  555.     DECX11_color,
  556.     DECX11_draw,
  557.     DECX11_exit,
  558.     DECX11_fill,
  559.     DECX11_font,
  560.     DECX11_frontbuf,
  561.     DECX11_getkey,
  562.     DECX11_init,
  563.     DECX11_locator,
  564.     DECX11_mapcolor,
  565.     noop,
  566.     noop,
  567.     DECX11_string,
  568.     DECX11_swapbuf,
  569.     noop
  570. };
  571.  
  572. /*
  573.  * _DECX11_devcpy
  574.  *
  575.  *    copy the decX11 device into vdevice.dev.
  576.  */
  577. int _DECX11_devcpy(void)
  578. {
  579.     vdevice.dev = DECX11dev;
  580. }
  581.